/**
 * 轻量级Prompt增强器
 * 
 * 特点：
 * - ✅ 不依赖大型JSON文件
 * - ✅ 规则直接硬编码
 * - ✅ 包体积小（< 5MB）
 * - ✅ 运行速度快
 * 
 * 数据来源：从以下知识库中提炼的通用规则
 * - 197,453 个unittest测试用例
 * - 6,550 个fuzz函数
 * - 12,752 个GN目标
 * - 163,178 个NDK/NAPI调用
 */

import { CompactPromptRules } from './CompactPromptRules';
import { ContextAwarePromptEnhancer } from './ContextAwarePromptEnhancer';
import { OutParameterMockGuidance } from './OutParameterMockGuidance';
import { MockOrganizationGuidance } from './MockOrganizationGuidance';
import { MockValidationGuidance } from './MockValidationGuidance';

export class LightweightPromptEnhancer {
    /**
     * 增强UT生成Prompt
     */
    static enhancePrompt(
        basePrompt: string, 
        sourceCode: string, 
        functionName?: string,
        classContext?: any  // 新增：类上下文和函数调用信息
    ): string {
        console.log(`\n🔮 [LightweightPromptEnhancer] 使用精简规则增强Prompt...`);
        
        // 分析源码特征
        const features = this.analyzeSourceFeatures(sourceCode);
        console.log(`   检测到: ${features.hasNdkNapi ? 'NDK/NAPI' : ''} ${features.hasCJson ? 'cJSON' : ''} ${features.hasParsing ? '解析函数' : ''} ${features.hasIPC ? 'IPC' : ''} ${features.hasConcurrency ? '并发' : ''}`);
        
        // 【精准识别】分析出参Mock场景（基于251,823个真实UT的0.42%使用率）
        const outParamAnalysis = OutParameterMockGuidance.analyzeOutParameters(sourceCode);
        if (outParamAnalysis.hasOutParams) {
            const confidenceLabel = outParamAnalysis.confidence === 'high' ? '🔴高' : outParamAnalysis.confidence === 'medium' ? '🟡中' : '🟢低';
            console.log(`   ⚠️ 检测到出参场景 [置信度:${confidenceLabel}]: ${outParamAnalysis.outParamPatterns.join(', ')}`);
            if (outParamAnalysis.hasLoopAfterCall) {
                console.log(`      ✓ 检测到出参变量被遍历: ${outParamAnalysis.outParamNames.join(', ')}`);
            }
        }
        
        // 如果有类上下文，输出统计信息
        if (classContext?.sourceClass) {
            const ctorCount = classContext.sourceClassConstructors?.public?.length || 0;
            const memberCount = classContext.sourceClassMembers?.length || 0;
            const funcCallCount = classContext.funcCalledList?.length || 0;
            console.log(`   类上下文: ${classContext.sourceClass} (${ctorCount}个构造函数, ${memberCount}个成员, 调用${funcCallCount}个函数)`);
        }
        
        // 获取相关规则（根据特征自动判断是否需要Fuzz规则）
        const needsFuzz = features.hasParsing || features.hasSerialization || 
                         features.hasStringProcessing || features.hasMemoryOps || features.hasIPC;
        const relevantRules = CompactPromptRules.getRelevantRules(sourceCode, needsFuzz, true);
        
        // 构建增强Prompt
        let enhancedPrompt = basePrompt;
        
        enhancedPrompt += '\n\n' + '='.repeat(80) + '\n';
        enhancedPrompt += '## 📚 OpenHarmony 项目经验总结（学习自 380,000+ 真实代码）\n';
        enhancedPrompt += '='.repeat(80) + '\n\n';
        
        enhancedPrompt += relevantRules;
        
        // 添加类上下文和函数调用关系（新增！）
        if (classContext && classContext.sourceClass) {
            enhancedPrompt = ContextAwarePromptEnhancer.enhanceWithFullContext(enhancedPrompt, classContext);
        }
        
        // 【Mock组织指导】检测到虚函数调用或接口依赖时添加
        if (classContext?.funcCalledList && classContext.funcCalledList.some((f: any) => f.isVirtual)) {
            enhancedPrompt += MockOrganizationGuidance.getGuidance();
            enhancedPrompt += MockValidationGuidance.getGuidance();  // ✅ 添加Mock验证指导
            console.log(`   ✅ 已添加Mock组织和验证指导（检测到虚函数调用）`);
        } else if (features.hasMock || /interface|IRemote|IPC/.test(sourceCode)) {
            enhancedPrompt += MockOrganizationGuidance.getGuidance();
            enhancedPrompt += MockValidationGuidance.getGuidance();  // ✅ 添加Mock验证指导
            console.log(`   ✅ 已添加Mock组织和验证指导（检测到Mock或接口依赖）`);
        }
        
        // 【权限相关特殊处理】如果检测到AccessToken/IPCSkeleton，强制添加验证指导
        if (/AccessToken|IPCSkeleton|VerifyAccessToken/.test(sourceCode)) {
            enhancedPrompt += MockValidationGuidance.getGuidance();
            console.log(`   🚨 检测到权限相关代码，已添加Mock验证指导（推荐使用SetNativeToken而非Mock）`);
        }
        
        // 【精准触发】添加出参Mock指导（只在中高置信度时触发）
        // 目标：准确识别，减少开发者改动
        if (outParamAnalysis.hasOutParams && 
            outParamAnalysis.hasLoopAfterCall && 
            (outParamAnalysis.confidence === 'high' || outParamAnalysis.confidence === 'medium')) {
            enhancedPrompt += OutParameterMockGuidance.getGuidance();
            console.log(`   ✅ 已添加出参Mock指导 [置信度:${outParamAnalysis.confidence}]`);
            console.log(`      需要填充的出参: ${outParamAnalysis.outParamNames.join(', ')}`);
        } else if (outParamAnalysis.hasOutParams && !outParamAnalysis.hasLoopAfterCall) {
            console.log(`   ℹ️ 检测到出参，但无遍历操作，跳过SetArgReferee指导`);
        } else if (outParamAnalysis.hasOutParams && outParamAnalysis.confidence === 'low') {
            console.log(`   ℹ️ 出参场景置信度较低，跳过SetArgReferee指导`);
        }
        
        // 添加特定函数的建议
        if (functionName) {
            enhancedPrompt += this.getFunctionSpecificAdvice(functionName, features);
        }
        
        console.log(`   ✓ Prompt 增强完成（包含类上下文、函数调用关系、出参Mock指导和最佳实践）`);
        return enhancedPrompt;
    }
    
    /**
     * 分析源码特征
     */
    private static analyzeSourceFeatures(sourceCode: string) {
        return {
            hasAccessToken: /AccessToken|IPCSkeleton|MockTokenId|VerifyAccessToken/.test(sourceCode),
            hasNdkNapi: /OH_\w+|napi_\w+/.test(sourceCode),
            hasCJson: /cJSON_\w+/.test(sourceCode),
            hasSmartPtr: /std::shared_ptr|std::unique_ptr|std::make_shared/.test(sourceCode),
            hasMock: /MOCK_METHOD|gmock/i.test(sourceCode),
            hasAsync: /async|Promise|callback/i.test(sourceCode),
            hasFileIO: /open|read|write|close|FILE\*|fstream/.test(sourceCode),
            hasNetwork: /socket|connect|send|recv|http/.test(sourceCode),
            hasDatabase: /sql|database|query/.test(sourceCode),
            // 检测单例模式调用方式
            hasSingletonRef: /GetInstance\(\)\./.test(sourceCode),  // 返回引用用.
            hasSingletonPtr: /GetInstance\(\)->/.test(sourceCode),  // 返回指针用->
            // 检测静态方法调用
            hasStaticMethod: /::[A-Z]\w+\(/.test(sourceCode),
            // 检测是否需要Fuzz测试的场景
            hasParsing: /Parse|Unmarshal|Deserialize|Decode/.test(sourceCode),  // 解析函数
            hasSerialization: /Marshal|Serialize|Encode/.test(sourceCode),  // 序列化函数
            hasStringProcessing: /strlen|strcpy|strcat|substr|replace/.test(sourceCode),  // 字符串处理
            hasMemoryOps: /memcpy|memset|malloc|free|new|delete/.test(sourceCode),  // 内存操作
            hasIPC: /MessageParcel|IPCObjectStub|IRemoteObject/.test(sourceCode),  // IPC通信
            hasConcurrency: /std::thread|std::mutex|std::atomic|pthread/.test(sourceCode),  // 并发相关
        };
    }
    
    /**
     * 获取特定函数的建议
     */
    private static getFunctionSpecificAdvice(functionName: string, features: any): string {
        let advice = '\n\n## 💡 针对当前函数的测试建议\n\n';
        
        // 首先强调最重要的规则
        advice += '### ⚠️ 最重要的规则\n';
        advice += '- ❌ **严禁在测试函数内直接实例化被测对象**（如：`TargetClass obj(params);`）\n';
        advice += '- ✅ **必须使用 instance_-> 调用方法**（instance_在SetUp中初始化）\n';
        advice += '- ✅ 测试函数开头必须检查：`ASSERT_NE(instance_, nullptr);`\n\n';
        
        if (features.hasAccessToken) {
            advice += '### 🔐 权限验证相关\n';
            advice += '- ✅ 测试权限时使用 `MockTokenId("foundation")` 或 `MockTokenId("accountmgr")`\n';
            advice += '- ✅ 获取TokenID: `IPCSkeleton::GetCallingTokenID()` 或 `IPCSkeleton::GetSelfTokenID()`\n';
            advice += '- ✅ 验证权限: `AccessTokenKit::VerifyAccessToken(tokenId, permission)`\n';
            advice += '- ✅ 检查结果: `EXPECT_EQ(res, Security::AccessToken::PERMISSION_GRANTED)`\n\n';
        }
        
        if (features.hasSmartPtr) {
            advice += '- ✅ 使用智能指针管理测试对象：在SetUp中用 make_shared 初始化，在TearDown中置nullptr\n';
        }
        
        if (features.hasMock) {
            advice += '- ✅ Mock类需要继承基类，使用MOCK_METHOD宏定义虚函数\n';
            advice += '- ✅ 在测试中使用EXPECT_CALL设置期望行为\n';
        }
        
        if (features.hasAsync) {
            advice += '- ✅ 异步函数需要等待回调完成，使用条件变量或sleep\n';
            advice += '- ✅ 测试异步错误处理和超时场景\n';
        }
        
        if (features.hasFileIO) {
            advice += '- ✅ 测试文件不存在、权限错误等异常场景\n';
            advice += '- ✅ 在TearDown中清理测试文件\n';
        }
        
        if (features.hasNdkNapi) {
            advice += '- ✅ 检查所有NDK/NAPI函数的返回状态码\n';
            advice += '- ✅ Create和Destroy函数必须成对出现\n';
        }
        
        if (features.hasCJson) {
            advice += '- ✅ cJSON_Parse后必须检查返回值\n';
            advice += '- ✅ 所有cJSON对象都必须调用cJSON_Delete释放\n';
        }
        
        // 单例模式和静态方法调用建议
        if (features.hasSingletonRef) {
            advice += '\n### 🔹 单例模式调用（返回引用）\n';
            advice += '- ✅ 检测到 `GetInstance().` 模式，说明返回的是引用\n';
            advice += '- ✅ 使用 `.` 调用成员方法和访问成员变量\n';
            advice += '- ✅ 示例：`PolicyInfoManager::GetInstance().SetPolicy(...)`\n';
        }
        
        if (features.hasSingletonPtr) {
            advice += '\n### 🔹 单例模式调用（返回指针）\n';
            advice += '- ✅ 检测到 `GetInstance()->` 模式，说明返回的是指针\n';
            advice += '- ✅ 使用 `->` 调用成员方法\n';
            advice += '- ✅ 示例：`PageCache::GetInstance()->NewSpan(size)`\n';
        }
        
        if (features.hasStaticMethod) {
            advice += '\n### 🔹 静态方法调用\n';
            advice += '- ✅ 检测到静态方法调用（使用 `::`）\n';
            advice += '- ✅ 无需实例化，直接通过类名调用\n';
            advice += '- ✅ 示例：`IPCSkeleton::GetCallingTokenID()`、`AccessTokenKit::VerifyAccessToken(...)`\n';
        }
        
        // 通用建议
        advice += '\n### 通用测试策略\n';
        advice += '1. 正常流程：测试典型使用场景\n';
        advice += '2. 边界条件：空指针、空字符串、最大最小值\n';
        advice += '3. 异常处理：测试各种错误场景\n';
        advice += '4. 状态检查：验证对象状态变化\n';
        
        // 【新增】Fuzz测试建议（如果检测到相关场景）
        if (features.hasParsing || features.hasSerialization || features.hasStringProcessing || features.hasMemoryOps || features.hasIPC) {
            advice += '\n### 🎯 Fuzz测试建议（推荐）\n';
            advice += '- ✅ 检测到解析、序列化、字符串处理或内存操作函数\n';
            advice += '- ✅ 建议额外编写Fuzz测试用例，发现内存安全漏洞\n';
            advice += '- ✅ Fuzz测试重点关注：空指针、越界访问、内存泄漏\n';
            if (features.hasParsing) {
                advice += '- 📝 解析函数：测试各种格式错误、边界数据\n';
            }
            if (features.hasStringProcessing) {
                advice += '- 📝 字符串处理：测试空字符串、超长字符串、特殊字符\n';
            }
            if (features.hasMemoryOps) {
                advice += '- 📝 内存操作：测试空指针、越界访问、内存对齐\n';
            }
            if (features.hasIPC) {
                advice += '- 📝 IPC通信：测试序列化/反序列化异常数据\n';
            }
        }
        
        // 【新增】并发测试建议（如果检测到并发相关代码）
        if (features.hasConcurrency) {
            advice += '\n### 🔄 并发安全测试（强烈推荐）\n';
            advice += '- ✅ 检测到并发相关代码（线程、互斥锁、原子操作）\n';
            advice += '- ✅ 必须测试多线程环境下的正确性\n';
            advice += '- ✅ 测试竞态条件、死锁、数据竞争\n';
            advice += '- ✅ 使用 std::thread 创建多个线程进行测试\n';
        }
        
        return advice;
    }
}

